macro_rules! magic_number {
    ($name:ident, $value:expr) => {
        const $name: u32 = $value;
    };
}
magic_number!(KEYC_MASK_FLAGS, 0xff000000);

extern "C" {
    pub type event_base;
    pub type evbuffer;
    pub type bufferevent_ops;
    pub type args;
    pub type tmuxpeer;
    pub type hyperlinks;
    pub type screen_write_cline;
    pub type screen_sel;
    pub type screen_titles;
    pub type environ;
    pub type options;
    pub type format_tree;
    pub type input_ctx;
    pub type cmds;
    pub type tty_key;
    pub type tty_code;
    pub type format_job_tree;
    pub type control_state;
    pub type cmdq_list;
    pub type cmdq_item;
    pub type mode_tree_data;
    pub type screen_write_citem;
    pub type paste_buffer;
    pub type mode_tree_item;
    fn free(_: *mut ());
    fn qsort(__base: *mut (), __nmemb: size_t, __size: size_t, __compar: __compar_fn_t);
    fn strcmp(_: *const i8, _: *const i8) -> i32;
    fn strstr(_: *const i8, _: *const i8) -> *mut i8;
    fn memmem(
        __haystack: *const (),
        __haystacklen: size_t,
        __needle: *const (),
        __needlelen: size_t,
    ) -> *mut ();
    fn strlen(_: *const i8) -> u64;
    fn xcalloc(_: size_t, _: size_t) -> *mut ();
    fn xreallocarray(_: *mut (), _: size_t, _: size_t) -> *mut ();
    fn xstrdup(_: *const i8) -> *mut i8;
    fn paste_buffer_name(_: *mut paste_buffer) -> *const i8;
    fn paste_buffer_order(_: *mut paste_buffer) -> u_int;
    fn paste_buffer_data(_: *mut paste_buffer, _: *mut size_t) -> *const i8;
    fn paste_walk(_: *mut paste_buffer) -> *mut paste_buffer;
    fn paste_is_empty() -> i32;
    fn paste_get_name(_: *const i8) -> *mut paste_buffer;
    fn paste_free(_: *mut paste_buffer);
    fn paste_replace(_: *mut paste_buffer, _: *mut i8, _: size_t);
    fn format_true(_: *const i8) -> i32;
    fn format_create(_: *mut client, _: *mut cmdq_item, _: i32, _: i32) -> *mut format_tree;
    fn format_free(_: *mut format_tree);
    fn format_add(_: *mut format_tree, _: *const i8, _: *const i8, _: ...);
    fn format_defaults_paste_buffer(_: *mut format_tree, _: *mut paste_buffer);
    fn args_has(_: *mut args, _: u_char) -> i32;
    fn args_get(_: *mut args, _: u_char) -> *const i8;
    fn args_count(_: *mut args) -> u_int;
    fn args_string(_: *mut args, _: u_int) -> *const i8;
    fn cmd_find_valid_state(_: *mut cmd_find_state) -> i32;
    fn cmd_find_copy_state(_: *mut cmd_find_state, _: *mut cmd_find_state);
    fn key_string_lookup_string(_: *const i8) -> key_code;
    static grid_default_cell: grid_cell;
    fn format_expand(_: *mut format_tree, _: *const i8) -> *mut i8;
    fn format_defaults(
        _: *mut format_tree,
        _: *mut client,
        _: *mut session,
        _: *mut winlink,
        _: *mut window_pane,
    );
    fn screen_write_nputs(
        _: *mut screen_write_ctx,
        _: ssize_t,
        _: *const grid_cell,
        _: *const i8,
        _: ...
    );
    fn screen_write_cursormove(_: *mut screen_write_ctx, _: i32, _: i32, _: i32);
    fn window_pane_find_by_id(_: u_int) -> *mut window_pane;
    fn window_pane_reset_mode(_: *mut window_pane);
    fn mode_tree_get_current(_: *mut mode_tree_data) -> *mut ();
    fn mode_tree_each_tagged(
        _: *mut mode_tree_data,
        _: mode_tree_each_cb,
        _: *mut client,
        _: key_code,
        _: i32,
    );
    fn mode_tree_up(_: *mut mode_tree_data, _: i32);
    fn mode_tree_down(_: *mut mode_tree_data, _: i32) -> i32;
    fn mode_tree_start(
        _: *mut window_pane,
        _: *mut args,
        _: mode_tree_build_cb,
        _: mode_tree_draw_cb,
        _: mode_tree_search_cb,
        _: mode_tree_menu_cb,
        _: mode_tree_height_cb,
        _: mode_tree_key_cb,
        _: *mut (),
        _: *const menu_item,
        _: *mut *const i8,
        _: u_int,
        _: *mut *mut screen,
    ) -> *mut mode_tree_data;
    fn mode_tree_zoom(_: *mut mode_tree_data, _: *mut args);
    fn mode_tree_build(_: *mut mode_tree_data);
    fn mode_tree_free(_: *mut mode_tree_data);
    fn mode_tree_resize(_: *mut mode_tree_data, _: u_int, _: u_int);
    fn mode_tree_add(
        _: *mut mode_tree_data,
        _: *mut mode_tree_item,
        _: *mut (),
        _: uint64_t,
        _: *const i8,
        _: *const i8,
        _: i32,
    ) -> *mut mode_tree_item;
    fn mode_tree_draw(_: *mut mode_tree_data);
    fn mode_tree_key(
        _: *mut mode_tree_data,
        _: *mut client,
        _: *mut key_code,
        _: *mut mouse_event,
        _: *mut u_int,
        _: *mut u_int,
    ) -> i32;
    fn mode_tree_run_command(_: *mut client, _: *mut cmd_find_state, _: *const i8, _: *const i8);
    fn utf8_strvis(_: *mut i8, _: *const i8, _: size_t, _: i32) -> i32;
    fn popup_editor(
        _: *mut client,
        _: *const i8,
        _: size_t,
        _: popup_finish_edit_cb,
        _: *mut (),
    ) -> i32;
}
pub type __u_char = u8;
pub type __u_short = u16;
pub type __u_int = u32;
pub type __uint8_t = u8;
pub type __uint64_t = u64;
pub type __pid_t = i32;
pub type __time_t = i64;
pub type __suseconds_t = i64;
pub type __ssize_t = i64;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type pid_t = __pid_t;
pub type ssize_t = __ssize_t;
pub type time_t = __time_t;
pub type size_t = u64;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
pub type __compar_fn_t =
    Option<unsafe extern "C" fn(*const (), *const ()) -> i32>;
pub type cc_t = u8;
pub type speed_t = u32;
pub type tcflag_t = u32;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct termios {
    pub c_iflag: tcflag_t,
    pub c_oflag: tcflag_t,
    pub c_cflag: tcflag_t,
    pub c_lflag: tcflag_t,
    pub c_line: cc_t,
    pub c_cc: [cc_t; 32],
    pub c_ispeed: speed_t,
    pub c_ospeed: speed_t,
}
pub type uint8_t = __uint8_t;
pub type uint64_t = __uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event {
    pub ev_evcallback: event_callback,
    pub ev_timeout_pos: C2RustUnnamed_4,
    pub ev_fd: i32,
    pub ev_base: *mut event_base,
    pub ev_: C2RustUnnamed,
    pub ev_events: i16,
    pub ev_res: i16,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
    pub ev_io: C2RustUnnamed_2,
    pub ev_signal: C2RustUnnamed_0,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
    pub ev_signal_next: C2RustUnnamed_1,
    pub ev_ncalls: i16,
    pub ev_pncalls: *mut i16,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub ev_io_next: C2RustUnnamed_3,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_3 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_4 {
    pub ev_next_with_common_timeout: C2RustUnnamed_5,
    pub min_heap_idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_5 {
    pub tqe_next: *mut event,
    pub tqe_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_callback {
    pub evcb_active_next: C2RustUnnamed_7,
    pub evcb_flags: i16,
    pub evcb_pri: uint8_t,
    pub evcb_closure: uint8_t,
    pub evcb_cb_union: C2RustUnnamed_6,
    pub evcb_arg: *mut (),
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_6 {
    pub evcb_callback: Option<unsafe extern "C" fn(i32, i16, *mut ()) -> ()>,
    pub evcb_selfcb: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
    pub evcb_evfinalize: Option<unsafe extern "C" fn(*mut event, *mut ()) -> ()>,
    pub evcb_cbfinalize: Option<unsafe extern "C" fn(*mut event_callback, *mut ()) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_7 {
    pub tqe_next: *mut event_callback,
    pub tqe_prev: *mut *mut event_callback,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct bufferevent {
    pub ev_base: *mut event_base,
    pub be_ops: *const bufferevent_ops,
    pub ev_read: event,
    pub ev_write: event,
    pub input: *mut evbuffer,
    pub output: *mut evbuffer,
    pub wm_read: event_watermark,
    pub wm_write: event_watermark,
    pub readcb: bufferevent_data_cb,
    pub writecb: bufferevent_data_cb,
    pub errorcb: bufferevent_event_cb,
    pub cbarg: *mut (),
    pub timeout_read: timeval,
    pub timeout_write: timeval,
    pub enabled: i16,
}
pub type bufferevent_event_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, i16, *mut ()) -> ()>;
pub type bufferevent_data_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, *mut ()) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_watermark {
    pub low: size_t,
    pub high: size_t,
}
pub type bitstr_t = u8;
pub type msgtype = u32;
pub const MSG_READ_CANCEL: msgtype = 307;
pub const MSG_WRITE_CLOSE: msgtype = 306;
pub const MSG_WRITE_READY: msgtype = 305;
pub const MSG_WRITE: msgtype = 304;
pub const MSG_WRITE_OPEN: msgtype = 303;
pub const MSG_READ_DONE: msgtype = 302;
pub const MSG_READ: msgtype = 301;
pub const MSG_READ_OPEN: msgtype = 300;
pub const MSG_FLAGS: msgtype = 218;
pub const MSG_EXEC: msgtype = 217;
pub const MSG_WAKEUP: msgtype = 216;
pub const MSG_UNLOCK: msgtype = 215;
pub const MSG_SUSPEND: msgtype = 214;
pub const MSG_OLDSTDOUT: msgtype = 213;
pub const MSG_OLDSTDIN: msgtype = 212;
pub const MSG_OLDSTDERR: msgtype = 211;
pub const MSG_SHUTDOWN: msgtype = 210;
pub const MSG_SHELL: msgtype = 209;
pub const MSG_RESIZE: msgtype = 208;
pub const MSG_READY: msgtype = 207;
pub const MSG_LOCK: msgtype = 206;
pub const MSG_EXITING: msgtype = 205;
pub const MSG_EXITED: msgtype = 204;
pub const MSG_EXIT: msgtype = 203;
pub const MSG_DETACHKILL: msgtype = 202;
pub const MSG_DETACH: msgtype = 201;
pub const MSG_COMMAND: msgtype = 200;
pub const MSG_IDENTIFY_TERMINFO: msgtype = 112;
pub const MSG_IDENTIFY_LONGFLAGS: msgtype = 111;
pub const MSG_IDENTIFY_STDOUT: msgtype = 110;
pub const MSG_IDENTIFY_FEATURES: msgtype = 109;
pub const MSG_IDENTIFY_CWD: msgtype = 108;
pub const MSG_IDENTIFY_CLIENTPID: msgtype = 107;
pub const MSG_IDENTIFY_DONE: msgtype = 106;
pub const MSG_IDENTIFY_ENVIRON: msgtype = 105;
pub const MSG_IDENTIFY_STDIN: msgtype = 104;
pub const MSG_IDENTIFY_OLDCWD: msgtype = 103;
pub const MSG_IDENTIFY_TTYNAME: msgtype = 102;
pub const MSG_IDENTIFY_TERM: msgtype = 101;
pub const MSG_IDENTIFY_FLAGS: msgtype = 100;
pub const MSG_VERSION: msgtype = 12;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client {
    pub name: *const i8,
    pub peer: *mut tmuxpeer,
    pub queue: *mut cmdq_list,
    pub windows: client_windows,
    pub control_state: *mut control_state,
    pub pause_age: u_int,
    pub pid: pid_t,
    pub fd: i32,
    pub out_fd: i32,
    pub event: event,
    pub retval: i32,
    pub creation_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub environ: *mut environ,
    pub jobs: *mut format_job_tree,
    pub title: *mut i8,
    pub path: *mut i8,
    pub cwd: *const i8,
    pub term_name: *mut i8,
    pub term_features: i32,
    pub term_type: *mut i8,
    pub term_caps: *mut *mut i8,
    pub term_ncaps: u_int,
    pub ttyname: *mut i8,
    pub tty: tty,
    pub written: size_t,
    pub discarded: size_t,
    pub redraw: size_t,
    pub repeat_timer: event,
    pub click_timer: event,
    pub click_button: u_int,
    pub click_event: mouse_event,
    pub status: status_line,
    pub flags: uint64_t,
    pub exit_type: C2RustUnnamed_30,
    pub exit_msgtype: msgtype,
    pub exit_session: *mut i8,
    pub exit_message: *mut i8,
    pub keytable: *mut key_table,
    pub last_key: key_code,
    pub redraw_panes: uint64_t,
    pub redraw_scrollbars: uint64_t,
    pub message_ignore_keys: i32,
    pub message_ignore_styles: i32,
    pub message_string: *mut i8,
    pub message_timer: event,
    pub prompt_string: *mut i8,
    pub prompt_buffer: *mut utf8_data,
    pub prompt_last: *mut i8,
    pub prompt_index: size_t,
    pub prompt_inputcb: prompt_input_cb,
    pub prompt_freecb: prompt_free_cb,
    pub prompt_data: *mut (),
    pub prompt_hindex: [u_int; 4],
    pub prompt_mode: C2RustUnnamed_27,
    pub prompt_saved: *mut utf8_data,
    pub prompt_flags: i32,
    pub prompt_type: prompt_type,
    pub prompt_cursor: i32,
    pub session: *mut session,
    pub last_session: *mut session,
    pub references: i32,
    pub pan_window: *mut (),
    pub pan_ox: u_int,
    pub pan_oy: u_int,
    pub overlay_check: overlay_check_cb,
    pub overlay_mode: overlay_mode_cb,
    pub overlay_draw: overlay_draw_cb,
    pub overlay_key: overlay_key_cb,
    pub overlay_free: overlay_free_cb,
    pub overlay_resize: overlay_resize_cb,
    pub overlay_data: *mut (),
    pub overlay_timer: event,
    pub files: client_files,
    pub clipboard_panes: *mut u_int,
    pub clipboard_npanes: u_int,
    pub entry: C2RustUnnamed_8,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_8 {
    pub tqe_next: *mut client,
    pub tqe_prev: *mut *mut client,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_files {
    pub rbh_root: *mut client_file,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_file {
    pub c: *mut client,
    pub peer: *mut tmuxpeer,
    pub tree: *mut client_files,
    pub references: i32,
    pub stream: i32,
    pub path: *mut i8,
    pub buffer: *mut evbuffer,
    pub event: *mut bufferevent,
    pub fd: i32,
    pub error: i32,
    pub closed: i32,
    pub cb: client_file_cb,
    pub data: *mut (),
    pub entry: C2RustUnnamed_9,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_9 {
    pub rbe_left: *mut client_file,
    pub rbe_right: *mut client_file,
    pub rbe_parent: *mut client_file,
    pub rbe_color: i32,
}
pub type client_file_cb = Option<
    unsafe extern "C" fn(*mut client, *const i8, i32, i32, *mut evbuffer, *mut ()) -> (),
>;
pub type overlay_resize_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_free_cb = Option<unsafe extern "C" fn(*mut client, *mut ()) -> ()>;
pub type overlay_key_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut key_event) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_event {
    pub key: key_code,
    pub m: mouse_event,
    pub buf: *mut i8,
    pub len: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mouse_event {
    pub valid: i32,
    pub ignore: i32,
    pub key: key_code,
    pub statusat: i32,
    pub statuslines: u_int,
    pub x: u_int,
    pub y: u_int,
    pub b: u_int,
    pub lx: u_int,
    pub ly: u_int,
    pub lb: u_int,
    pub ox: u_int,
    pub oy: u_int,
    pub s: i32,
    pub w: i32,
    pub wp: i32,
    pub sgr_type: u_int,
    pub sgr_b: u_int,
}
pub type key_code = u64;
pub type overlay_draw_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *mut screen_redraw_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_redraw_ctx {
    pub c: *mut client,
    pub statuslines: u_int,
    pub statustop: i32,
    pub pane_status: i32,
    pub pane_lines: pane_lines,
    pub pane_scrollbars: i32,
    pub pane_scrollbars_pos: i32,
    pub no_pane_gc: grid_cell,
    pub no_pane_gc_set: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub ox: u_int,
    pub oy: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_cell {
    pub data: utf8_data,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct utf8_data {
    pub data: [u_char; 21],
    pub have: u_char,
    pub size: u_char,
    pub width: u_char,
}
pub type pane_lines = u32;
pub const PANE_LINES_NUMBER: pane_lines = 4;
pub const PANE_LINES_SIMPLE: pane_lines = 3;
pub const PANE_LINES_HEAVY: pane_lines = 2;
pub const PANE_LINES_DOUBLE: pane_lines = 1;
pub const PANE_LINES_SINGLE: pane_lines = 0;
pub type overlay_mode_cb = Option<
    unsafe extern "C" fn(*mut client, *mut (), *mut u_int, *mut u_int) -> *mut screen,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen {
    pub title: *mut i8,
    pub path: *mut i8,
    pub titles: *mut screen_titles,
    pub grid: *mut grid,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub default_cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub default_ccolour: i32,
    pub rupper: u_int,
    pub rlower: u_int,
    pub mode: i32,
    pub default_mode: i32,
    pub saved_cx: u_int,
    pub saved_cy: u_int,
    pub saved_grid: *mut grid,
    pub saved_cell: grid_cell,
    pub saved_flags: i32,
    pub tabs: *mut bitstr_t,
    pub sel: *mut screen_sel,
    pub write_list: *mut screen_write_cline,
    pub hyperlinks: *mut hyperlinks,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid {
    pub flags: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub hscrolled: u_int,
    pub hsize: u_int,
    pub hlimit: u_int,
    pub linedata: *mut grid_line,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_line {
    pub celldata: *mut grid_cell_entry,
    pub cellused: u_int,
    pub cellsize: u_int,
    pub extddata: *mut grid_extd_entry,
    pub extdsize: u_int,
    pub flags: i32,
    pub time: time_t,
}
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_extd_entry {
    pub data: utf8_char,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
pub type utf8_char = u_int;
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_cell_entry {
    pub c2rust_unnamed: C2RustUnnamed_10,
    pub flags: u_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_10 {
    pub offset: u_int,
    pub data: C2RustUnnamed_11,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_11 {
    pub attr: u_char,
    pub fg: u_char,
    pub bg: u_char,
    pub data: u_char,
}
pub type screen_cursor_style = u32;
pub const SCREEN_CURSOR_BAR: screen_cursor_style = 3;
pub const SCREEN_CURSOR_UNDERLINE: screen_cursor_style = 2;
pub const SCREEN_CURSOR_BLOCK: screen_cursor_style = 1;
pub const SCREEN_CURSOR_DEFAULT: screen_cursor_style = 0;
pub type overlay_check_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut (),
        u_int,
        u_int,
        u_int,
        *mut overlay_ranges,
    ) -> (),
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct overlay_ranges {
    pub px: [u_int; 3],
    pub nx: [u_int; 3],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct session {
    pub id: u_int,
    pub name: *mut i8,
    pub cwd: *const i8,
    pub creation_time: timeval,
    pub last_attached_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub lock_timer: event,
    pub curw: *mut winlink,
    pub lastw: winlink_stack,
    pub windows: winlinks,
    pub statusat: i32,
    pub statuslines: u_int,
    pub options: *mut options,
    pub flags: i32,
    pub attached: u_int,
    pub tio: *mut termios,
    pub environ: *mut environ,
    pub references: i32,
    pub gentry: C2RustUnnamed_13,
    pub entry: C2RustUnnamed_12,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_12 {
    pub rbe_left: *mut session,
    pub rbe_right: *mut session,
    pub rbe_parent: *mut session,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_13 {
    pub tqe_next: *mut session,
    pub tqe_prev: *mut *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlinks {
    pub rbh_root: *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink {
    pub idx: i32,
    pub session: *mut session,
    pub window: *mut window,
    pub flags: i32,
    pub entry: C2RustUnnamed_16,
    pub wentry: C2RustUnnamed_15,
    pub sentry: C2RustUnnamed_14,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_14 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_15 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_16 {
    pub rbe_left: *mut winlink,
    pub rbe_right: *mut winlink,
    pub rbe_parent: *mut winlink,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window {
    pub id: u_int,
    pub latest: *mut (),
    pub name: *mut i8,
    pub name_event: event,
    pub name_time: timeval,
    pub alerts_timer: event,
    pub offset_timer: event,
    pub activity_time: timeval,
    pub active: *mut window_pane,
    pub last_panes: window_panes,
    pub panes: window_panes,
    pub lastlayout: i32,
    pub layout_root: *mut layout_cell,
    pub saved_layout_root: *mut layout_cell,
    pub old_layout: *mut i8,
    pub sx: u_int,
    pub sy: u_int,
    pub manual_sx: u_int,
    pub manual_sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub new_sx: u_int,
    pub new_sy: u_int,
    pub new_xpixel: u_int,
    pub new_ypixel: u_int,
    pub fill_character: *mut utf8_data,
    pub flags: i32,
    pub alerts_queued: i32,
    pub alerts_entry: C2RustUnnamed_19,
    pub options: *mut options,
    pub references: u_int,
    pub winlinks: C2RustUnnamed_18,
    pub entry: C2RustUnnamed_17,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_17 {
    pub rbe_left: *mut window,
    pub rbe_right: *mut window,
    pub rbe_parent: *mut window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_18 {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_19 {
    pub tqe_next: *mut window,
    pub tqe_prev: *mut *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cell {
    pub type_0: layout_type,
    pub parent: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub wp: *mut window_pane,
    pub cells: layout_cells,
    pub entry: C2RustUnnamed_20,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_20 {
    pub tqe_next: *mut layout_cell,
    pub tqe_prev: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cells {
    pub tqh_first: *mut layout_cell,
    pub tqh_last: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane {
    pub id: u_int,
    pub active_point: u_int,
    pub window: *mut window,
    pub options: *mut options,
    pub layout_cell: *mut layout_cell,
    pub saved_layout_cell: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub flags: i32,
    pub sb_slider_y: u_int,
    pub sb_slider_h: u_int,
    pub argc: i32,
    pub argv: *mut *mut i8,
    pub shell: *mut i8,
    pub cwd: *mut i8,
    pub pid: pid_t,
    pub tty: [i8; 32],
    pub status: i32,
    pub dead_time: timeval,
    pub fd: i32,
    pub event: *mut bufferevent,
    pub offset: window_pane_offset,
    pub base_offset: size_t,
    pub resize_queue: window_pane_resizes,
    pub resize_timer: event,
    pub ictx: *mut input_ctx,
    pub cached_gc: grid_cell,
    pub cached_active_gc: grid_cell,
    pub palette: colour_palette,
    pub pipe_fd: i32,
    pub pipe_event: *mut bufferevent,
    pub pipe_offset: window_pane_offset,
    pub screen: *mut screen,
    pub base: screen,
    pub status_screen: screen,
    pub status_size: size_t,
    pub modes: C2RustUnnamed_24,
    pub searchstr: *mut i8,
    pub searchregex: i32,
    pub border_gc_set: i32,
    pub border_gc: grid_cell,
    pub control_bg: i32,
    pub control_fg: i32,
    pub scrollbar_style: style,
    pub entry: C2RustUnnamed_23,
    pub sentry: C2RustUnnamed_22,
    pub tree_entry: C2RustUnnamed_21,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_21 {
    pub rbe_left: *mut window_pane,
    pub rbe_right: *mut window_pane,
    pub rbe_parent: *mut window_pane,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_22 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_23 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style {
    pub gc: grid_cell,
    pub ignore: i32,
    pub fill: i32,
    pub align: style_align,
    pub list: style_list,
    pub range_type: style_range_type,
    pub range_argument: u_int,
    pub range_string: [i8; 16],
    pub width: i32,
    pub pad: i32,
    pub default_type: style_default_type,
}
pub type style_default_type = u32;
pub const STYLE_DEFAULT_POP: style_default_type = 2;
pub const STYLE_DEFAULT_PUSH: style_default_type = 1;
pub const STYLE_DEFAULT_BASE: style_default_type = 0;
pub type style_range_type = u32;
pub const STYLE_RANGE_USER: style_range_type = 6;
pub const STYLE_RANGE_SESSION: style_range_type = 5;
pub const STYLE_RANGE_WINDOW: style_range_type = 4;
pub const STYLE_RANGE_PANE: style_range_type = 3;
pub const STYLE_RANGE_RIGHT: style_range_type = 2;
pub const STYLE_RANGE_LEFT: style_range_type = 1;
pub const STYLE_RANGE_NONE: style_range_type = 0;
pub type style_list = u32;
pub const STYLE_LIST_RIGHT_MARKER: style_list = 4;
pub const STYLE_LIST_LEFT_MARKER: style_list = 3;
pub const STYLE_LIST_FOCUS: style_list = 2;
pub const STYLE_LIST_ON: style_list = 1;
pub const STYLE_LIST_OFF: style_list = 0;
pub type style_align = u32;
pub const STYLE_ALIGN_ABSOLUTE_CENTRE: style_align = 4;
pub const STYLE_ALIGN_RIGHT: style_align = 3;
pub const STYLE_ALIGN_CENTRE: style_align = 2;
pub const STYLE_ALIGN_LEFT: style_align = 1;
pub const STYLE_ALIGN_DEFAULT: style_align = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_24 {
    pub tqh_first: *mut window_mode_entry,
    pub tqh_last: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode_entry {
    pub wp: *mut window_pane,
    pub swp: *mut window_pane,
    pub mode: *const window_mode,
    pub data: *mut (),
    pub screen: *mut screen,
    pub prefix: u_int,
    pub entry: C2RustUnnamed_25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_25 {
    pub tqe_next: *mut window_mode_entry,
    pub tqe_prev: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode {
    pub name: *const i8,
    pub default_format: *const i8,
    pub init: Option<
        unsafe extern "C" fn(*mut window_mode_entry, *mut cmd_find_state, *mut args) -> *mut screen,
    >,
    pub free: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub resize: Option<unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> ()>,
    pub update: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub key: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            key_code,
            *mut mouse_event,
        ) -> (),
    >,
    pub key_table: Option<unsafe extern "C" fn(*mut window_mode_entry) -> *const i8>,
    pub command: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            *mut args,
            *mut mouse_event,
        ) -> (),
    >,
    pub formats: Option<unsafe extern "C" fn(*mut window_mode_entry, *mut format_tree) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_find_state {
    pub flags: i32,
    pub current: *mut cmd_find_state,
    pub s: *mut session,
    pub wl: *mut winlink,
    pub w: *mut window,
    pub wp: *mut window_pane,
    pub idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_offset {
    pub used: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct colour_palette {
    pub fg: i32,
    pub bg: i32,
    pub palette: *mut i32,
    pub default_palette: *mut i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resizes {
    pub tqh_first: *mut window_pane_resize,
    pub tqh_last: *mut *mut window_pane_resize,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resize {
    pub sx: u_int,
    pub sy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub entry: C2RustUnnamed_26,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_26 {
    pub tqe_next: *mut window_pane_resize,
    pub tqe_prev: *mut *mut window_pane_resize,
}
pub type layout_type = u32;
pub const LAYOUT_WINDOWPANE: layout_type = 2;
pub const LAYOUT_TOPBOTTOM: layout_type = 1;
pub const LAYOUT_LEFTRIGHT: layout_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_panes {
    pub tqh_first: *mut window_pane,
    pub tqh_last: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink_stack {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
pub type prompt_type = u32;
pub const PROMPT_TYPE_INVALID: prompt_type = 255;
pub const PROMPT_TYPE_WINDOW_TARGET: prompt_type = 3;
pub const PROMPT_TYPE_TARGET: prompt_type = 2;
pub const PROMPT_TYPE_SEARCH: prompt_type = 1;
pub const PROMPT_TYPE_COMMAND: prompt_type = 0;
pub type C2RustUnnamed_27 = u32;
pub const PROMPT_COMMAND: C2RustUnnamed_27 = 1;
pub const PROMPT_ENTRY: C2RustUnnamed_27 = 0;
pub type prompt_free_cb = Option<unsafe extern "C" fn(*mut ()) -> ()>;
pub type prompt_input_cb =
    Option<unsafe extern "C" fn(*mut client, *mut (), *const i8, i32) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_table {
    pub name: *const i8,
    pub activity_time: timeval,
    pub key_bindings: key_bindings,
    pub default_key_bindings: key_bindings,
    pub references: u_int,
    pub entry: C2RustUnnamed_28,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_28 {
    pub rbe_left: *mut key_table,
    pub rbe_right: *mut key_table,
    pub rbe_parent: *mut key_table,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_bindings {
    pub rbh_root: *mut key_binding,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_binding {
    pub key: key_code,
    pub cmdlist: *mut cmd_list,
    pub note: *const i8,
    pub flags: i32,
    pub entry: C2RustUnnamed_29,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_29 {
    pub rbe_left: *mut key_binding,
    pub rbe_right: *mut key_binding,
    pub rbe_parent: *mut key_binding,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_list {
    pub references: i32,
    pub group: u_int,
    pub list: *mut cmds,
}
pub type C2RustUnnamed_30 = u32;
pub const CLIENT_EXIT_DETACH: C2RustUnnamed_30 = 2;
pub const CLIENT_EXIT_SHUTDOWN: C2RustUnnamed_30 = 1;
pub const CLIENT_EXIT_RETURN: C2RustUnnamed_30 = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line {
    pub timer: event,
    pub screen: screen,
    pub active: *mut screen,
    pub references: i32,
    pub style: grid_cell,
    pub entries: [status_line_entry; 5],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line_entry {
    pub expanded: *mut i8,
    pub ranges: style_ranges,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_ranges {
    pub tqh_first: *mut style_range,
    pub tqh_last: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_range {
    pub type_0: style_range_type,
    pub argument: u_int,
    pub string: [i8; 16],
    pub start: u_int,
    pub end: u_int,
    pub entry: C2RustUnnamed_31,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_31 {
    pub tqe_next: *mut style_range,
    pub tqe_prev: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty {
    pub client: *mut client,
    pub start_timer: event,
    pub clipboard_timer: event,
    pub last_requests: time_t,
    pub sx: u_int,
    pub sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub oflag: i32,
    pub oox: u_int,
    pub ooy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub mode: i32,
    pub fg: i32,
    pub bg: i32,
    pub rlower: u_int,
    pub rupper: u_int,
    pub rleft: u_int,
    pub rright: u_int,
    pub event_in: event,
    pub in_0: *mut evbuffer,
    pub event_out: event,
    pub out: *mut evbuffer,
    pub timer: event,
    pub discarded: size_t,
    pub tio: termios,
    pub cell: grid_cell,
    pub last_cell: grid_cell,
    pub flags: i32,
    pub term: *mut tty_term,
    pub mouse_last_x: u_int,
    pub mouse_last_y: u_int,
    pub mouse_last_b: u_int,
    pub mouse_drag_flag: i32,
    pub mouse_scrolling_flag: i32,
    pub mouse_slider_mpos: i32,
    pub mouse_drag_update: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub mouse_drag_release: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub key_timer: event,
    pub key_tree: *mut tty_key,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_term {
    pub name: *mut i8,
    pub tty: *mut tty,
    pub features: i32,
    pub acs: [[i8; 2]; 256],
    pub codes: *mut tty_code,
    pub flags: i32,
    pub entry: C2RustUnnamed_32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_32 {
    pub le_next: *mut tty_term,
    pub le_prev: *mut *mut tty_term,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_windows {
    pub rbh_root: *mut client_window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_window {
    pub window: u_int,
    pub pane: *mut window_pane,
    pub sx: u_int,
    pub sy: u_int,
    pub entry: C2RustUnnamed_33,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_33 {
    pub rbe_left: *mut client_window,
    pub rbe_right: *mut client_window,
    pub rbe_parent: *mut client_window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_write_ctx {
    pub wp: *mut window_pane,
    pub s: *mut screen,
    pub flags: i32,
    pub init_ctx_cb: screen_write_init_ctx_cb,
    pub arg: *mut (),
    pub item: *mut screen_write_citem,
    pub scrolled: u_int,
    pub bg: u_int,
}
pub type screen_write_init_ctx_cb =
    Option<unsafe extern "C" fn(*mut screen_write_ctx, *mut tty_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_ctx {
    pub s: *mut screen,
    pub redraw_cb: tty_ctx_redraw_cb,
    pub set_client_cb: tty_ctx_set_client_cb,
    pub arg: *mut (),
    pub cell: *const grid_cell,
    pub wrapped: i32,
    pub num: u_int,
    pub ptr: *mut (),
    pub ptr2: *mut (),
    pub allow_invisible_panes: i32,
    pub ocx: u_int,
    pub ocy: u_int,
    pub orupper: u_int,
    pub orlower: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub rxoff: u_int,
    pub ryoff: u_int,
    pub sx: u_int,
    pub sy: u_int,
    pub bg: u_int,
    pub defaults: grid_cell,
    pub palette: *mut colour_palette,
    pub bigger: i32,
    pub wox: u_int,
    pub woy: u_int,
    pub wsx: u_int,
    pub wsy: u_int,
}
pub type tty_ctx_set_client_cb = Option<unsafe extern "C" fn(*mut tty_ctx, *mut client) -> i32>;
pub type tty_ctx_redraw_cb = Option<unsafe extern "C" fn(*const tty_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct menu_item {
    pub name: *const i8,
    pub key: key_code,
    pub command: *const i8,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mode_tree_sort_criteria {
    pub field: u_int,
    pub reversed: i32,
}
pub type mode_tree_build_cb = Option<
    unsafe extern "C" fn(
        *mut (),
        *mut mode_tree_sort_criteria,
        *mut uint64_t,
        *const i8,
    ) -> (),
>;
pub type mode_tree_draw_cb = Option<
    unsafe extern "C" fn(
        *mut (),
        *mut (),
        *mut screen_write_ctx,
        u_int,
        u_int,
    ) -> (),
>;
pub type mode_tree_search_cb =
    Option<unsafe extern "C" fn(*mut (), *mut (), *const i8) -> i32>;
pub type mode_tree_menu_cb =
    Option<unsafe extern "C" fn(*mut (), *mut client, key_code) -> ()>;
pub type mode_tree_height_cb = Option<unsafe extern "C" fn(*mut (), u_int) -> u_int>;
pub type mode_tree_key_cb =
    Option<unsafe extern "C" fn(*mut (), *mut (), u_int) -> key_code>;
pub type mode_tree_each_cb =
    Option<unsafe extern "C" fn(*mut (), *mut (), *mut client, key_code) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_buffer_modedata {
    pub wp: *mut window_pane,
    pub fs: cmd_find_state,
    pub data: *mut mode_tree_data,
    pub command: *mut i8,
    pub format: *mut i8,
    pub key_format: *mut i8,
    pub item_list: *mut *mut window_buffer_itemdata,
    pub item_size: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_buffer_itemdata {
    pub name: *const i8,
    pub order: u_int,
    pub size: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_buffer_editdata {
    pub wp_id: u_int,
    pub name: *mut i8,
    pub pb: *mut paste_buffer,
}
pub type popup_finish_edit_cb =
    Option<unsafe extern "C" fn(*mut i8, size_t, *mut ()) -> ()>;
pub const WINDOW_BUFFER_BY_SIZE: window_buffer_sort_type = 2;
pub const WINDOW_BUFFER_BY_TIME: window_buffer_sort_type = 0;
pub type window_buffer_sort_type = u32;
pub const WINDOW_BUFFER_BY_NAME: window_buffer_sort_type = 1;
static mut window_buffer_menu_items: [menu_item; 12] = [
    {
        let mut init = menu_item {
            name: b"Paste\0" as *const u8 as *const i8,
            key: 'p' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Paste Tagged\0" as *const u8 as *const i8,
            key: 'P' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"\0" as *const u8 as *const i8,
            key: KEYC_MASK_FLAGS000 as u64,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Tag\0" as *const u8 as *const i8,
            key: 't' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Tag All\0" as *const u8 as *const i8,
            key: '\u{14}' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Tag None\0" as *const u8 as *const i8,
            key: 'T' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"\0" as *const u8 as *const i8,
            key: KEYC_MASK_FLAGS000 as u64,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Delete\0" as *const u8 as *const i8,
            key: 'd' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Delete Tagged\0" as *const u8 as *const i8,
            key: 'D' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"\0" as *const u8 as *const i8,
            key: KEYC_MASK_FLAGS000 as u64,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: b"Cancel\0" as *const u8 as *const i8,
            key: 'q' as i32 as key_code,
            command: 0 as *const i8,
        };
        init
    },
    {
        let mut init = menu_item {
            name: 0 as *const i8,
            key: KEYC_MASK_FLAGS000 as u64,
            command: 0 as *const i8,
        };
        init
    },
];
#[no_mangle]
pub static mut window_buffer_mode: window_mode = {
    {
        let mut init = window_mode {
            name: b"buffer-mode\0" as *const u8 as *const i8,
            default_format: b"#{t/p:buffer_created}: #{buffer_sample}\0" as *const u8 as *const i8,
            init: Some(
                window_buffer_init
                    as unsafe extern "C" fn(
                        *mut window_mode_entry,
                        *mut cmd_find_state,
                        *mut args,
                    ) -> *mut screen,
            ),
            free: Some(window_buffer_free as unsafe extern "C" fn(*mut window_mode_entry) -> ()),
            resize: Some(
                window_buffer_resize
                    as unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> (),
            ),
            update: Some(
                window_buffer_update as unsafe extern "C" fn(*mut window_mode_entry) -> (),
            ),
            key: Some(
                window_buffer_key
                    as unsafe extern "C" fn(
                        *mut window_mode_entry,
                        *mut client,
                        *mut session,
                        *mut winlink,
                        key_code,
                        *mut mouse_event,
                    ) -> (),
            ),
            key_table: None,
            command: None,
            formats: None,
        };
        init
    }
};
static mut window_buffer_sort_list: [*const i8; 3] = [
    b"time\0" as *const u8 as *const i8,
    b"name\0" as *const u8 as *const i8,
    b"size\0" as *const u8 as *const i8,
];
static mut window_buffer_sort: *mut mode_tree_sort_criteria =
    0 as *const mode_tree_sort_criteria as *mut mode_tree_sort_criteria;
extern "C" fn window_buffer_add_item(
    mut data: *mut window_buffer_modedata,
) -> *mut window_buffer_itemdata {
    let mut item: *mut window_buffer_itemdata = std::ptr::null_mut::<window_buffer_itemdata>();
    (unsafe {
        (*data).item_list = xreallocarray(
            (*data).item_list as *mut (),
            ((*data).item_size).wrapping_add(1 as i32 as u32) as size_t,
            ::core::mem::size_of::<*mut window_buffer_itemdata>() as u64,
        ) as *mut *mut window_buffer_itemdata
    });
    let fresh0 = unsafe { (*data).item_size };
    (unsafe { (*data).item_size = ((*data).item_size).wrapping_add(1) });
    let fresh1 = unsafe { &mut (*((*data).item_list).offset(fresh0 as isize)) };
    *fresh1 = (unsafe {
        xcalloc( 1 as size_t,
            ::core::mem::size_of::<window_buffer_itemdata>() as u64,
        )
    }) as *mut window_buffer_itemdata;
    item = *fresh1;
    return item;
}
extern "C" fn window_buffer_free_item(mut item: *mut window_buffer_itemdata) {
    (unsafe { free((*item).name as *mut ()) });
    (unsafe { free(item as *mut ()) });
}
extern "C" fn window_buffer_cmp(mut a0: *const (), mut b0: *const ()) -> i32 {
    let mut a: *const *const window_buffer_itemdata = a0 as *const *const window_buffer_itemdata;
    let mut b: *const *const window_buffer_itemdata = b0 as *const *const window_buffer_itemdata;
    let mut result: i32 = 0;
    if (unsafe { (*window_buffer_sort).field }) == WINDOW_BUFFER_BY_TIME as i32 as u32 {
        result = (unsafe { (**b).order }).wrapping_sub(unsafe { (**a).order }) as i32;
    } else if (unsafe { (*window_buffer_sort).field }) == WINDOW_BUFFER_BY_SIZE as i32 as u32 {
        result = (unsafe { (**b).size }).wrapping_sub(unsafe { (**a).size }) as i32;
    }
    if result == 0 {
        result = unsafe { strcmp((**a).name, (**b).name) };
    }
    if (unsafe { (*window_buffer_sort).reversed }) != 0 {
        result = -result;
    }
    return result;
}
extern "C" fn window_buffer_build(
    mut modedata: *mut (),
    mut sort_crit: *mut mode_tree_sort_criteria,
    mut _tag: *mut uint64_t,
    mut filter: *const i8,
) {
    let mut data: *mut window_buffer_modedata = modedata as *mut window_buffer_modedata;
    let mut item: *mut window_buffer_itemdata = std::ptr::null_mut::<window_buffer_itemdata>();
    let mut i: u_int = 0;
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut text: *mut i8 = std::ptr::null_mut::<i8>();
    let mut cp: *mut i8 = std::ptr::null_mut::<i8>();
    let mut ft: *mut format_tree = std::ptr::null_mut::<format_tree>();
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    i = 0 as u_int;
    while i < (unsafe { (*data).item_size }) {
        window_buffer_free_item(unsafe { *((*data).item_list).offset(i as isize) });
        i = i.wrapping_add(1);
    }
    (unsafe { free((*data).item_list as *mut ()) });
    (unsafe { (*data).item_list = std::ptr::null_mut::<*mut window_buffer_itemdata>() });
    (unsafe { (*data).item_size = 0 as u_int });
    pb = std::ptr::null_mut::<paste_buffer>();
    loop {
        pb = unsafe { paste_walk(pb) };
        if pb.is_null() {
            break;
        }
        item = window_buffer_add_item(data);
        (unsafe { (*item).name = xstrdup(paste_buffer_name(pb)) });
        (unsafe { paste_buffer_data(pb, &mut (*item).size) });
        (unsafe { (*item).order = paste_buffer_order(pb) });
    }
    (unsafe { window_buffer_sort = sort_crit });
    (unsafe {
        qsort(
            (*data).item_list as *mut (),
            (*data).item_size as size_t,
            ::core::mem::size_of::<*mut window_buffer_itemdata>() as u64,
            Some(
                window_buffer_cmp
                    as unsafe extern "C" fn(*const (), *const ()) -> i32,
            ),
        )
    });
    if (unsafe { cmd_find_valid_state(&mut (*data).fs) }) != 0 {
        s = unsafe { (*data).fs.s };
        wl = unsafe { (*data).fs.wl };
        wp = unsafe { (*data).fs.wp };
    }
    let mut current_block_33: u64;
    i = 0 as u_int;
    while i < (unsafe { (*data).item_size }) {
        item = unsafe { *((*data).item_list).offset(i as isize) };
        pb = unsafe { paste_get_name((*item).name) };
        if !pb.is_null() {
            ft = unsafe {
                format_create(
                    std::ptr::null_mut::<client>(),
                    std::ptr::null_mut::<cmdq_item>(), 0, 0,
                )
            };
            (unsafe { format_defaults(ft, std::ptr::null_mut::<client>(), s, wl, wp) });
            (unsafe { format_defaults_paste_buffer(ft, pb) });
            if !filter.is_null() {
                cp = unsafe { format_expand(ft, filter) };
                if (unsafe { format_true(cp) }) == 0 {
                    (unsafe { free(cp as *mut ()) });
                    (unsafe { format_free(ft) });
                    current_block_33 = 15904375183555213903;
                } else {
                    (unsafe { free(cp as *mut ()) });
                    current_block_33 = 14359455889292382949;
                }
            } else {
                current_block_33 = 14359455889292382949;
            }
            match current_block_33 {
                15904375183555213903 => {}
                _ => {
                    text = unsafe { format_expand(ft, (*data).format) };
                    (unsafe {
                        mode_tree_add(
                            (*data).data,
                            std::ptr::null_mut::<mode_tree_item>(),
                            item as *mut (),
                            (*item).order as uint64_t,
                            (*item).name,
                            text,
                            -(1 as i32),
                        )
                    });
                    (unsafe { free(text as *mut ()) });
                    (unsafe { format_free(ft) });
                }
            }
        }
        i = i.wrapping_add(1);
    }
}
extern "C" fn window_buffer_draw(
    mut _modedata: *mut (),
    mut itemdata: *mut (),
    mut ctx: *mut screen_write_ctx,
    mut sx: u_int,
    mut sy: u_int,
) {
    let mut item: *mut window_buffer_itemdata = itemdata as *mut window_buffer_itemdata;
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut pdata: *const i8 = std::ptr::null::<i8>();
    let mut start: *const i8 = std::ptr::null::<i8>();
    let mut end: *const i8 = std::ptr::null::<i8>();
    let mut buf: *mut i8 = std::ptr::null_mut::<i8>();
    let mut psize: size_t = 0;
    let mut i: u_int = 0;
    let mut cx: u_int = unsafe { (*(*ctx).s).cx };
    let mut cy: u_int = unsafe { (*(*ctx).s).cy };
    pb = unsafe { paste_get_name((*item).name) };
    if pb.is_null() {
        return;
    }
    end = unsafe { paste_buffer_data(pb, &mut psize) };
    pdata = end;
    i = 0 as u_int;
    while i < sy {
        start = end;
        while end != (unsafe { pdata.offset(psize as isize) })
            && (unsafe { *end }) as i32 != '\n' as i32
        {
            end = unsafe { end.offset(1) };
        }
        buf = (unsafe {
            xreallocarray(
                buf as *mut (), 4 as size_t,
                (end.offset_from(start) as i64 + 1 as i64) as size_t,
            )
        }) as *mut i8;
        (unsafe {
            utf8_strvis(
                buf,
                start,
                end.offset_from(start) as i64 as size_t,
                0x1 as i32 | 0x2 as i32 | 0x8 as i32,
            )
        });
        if (unsafe { *buf }) as i32 != '\0' as i32 {
            (unsafe {
                screen_write_cursormove(ctx, cx as i32, cy.wrapping_add(i) as i32, 0)
            });
            (unsafe {
                screen_write_nputs(
                    ctx,
                    sx as ssize_t,
                    &grid_default_cell as *const grid_cell,
                    b"%s\0" as *const u8 as *const i8,
                    buf,
                )
            });
        }
        if end == (unsafe { pdata.offset(psize as isize) }) {
            break;
        }
        end = unsafe { end.offset(1) };
        i = i.wrapping_add(1);
    }
    (unsafe { free(buf as *mut ()) });
}
extern "C" fn window_buffer_search(
    mut _modedata: *mut (),
    mut itemdata: *mut (),
    mut ss: *const i8,
) -> i32 {
    let mut item: *mut window_buffer_itemdata = itemdata as *mut window_buffer_itemdata;
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut bufdata: *const i8 = std::ptr::null::<i8>();
    let mut bufsize: size_t = 0;
    pb = unsafe { paste_get_name((*item).name) };
    if pb.is_null() {
        return 0;
    }
    if !(unsafe { strstr((*item).name, ss) }).is_null() {
        return 1;
    }
    bufdata = unsafe { paste_buffer_data(pb, &mut bufsize) };
    return ((unsafe {
        memmem(
            bufdata as *const (),
            bufsize,
            ss as *const (),
            strlen(ss),
        )
    }) != std::ptr::null_mut::<()>()) as i32;
}
extern "C" fn window_buffer_menu(
    mut modedata: *mut (),
    mut c: *mut client,
    mut key: key_code,
) {
    let mut data: *mut window_buffer_modedata = modedata as *mut window_buffer_modedata;
    let mut wp: *mut window_pane = unsafe { (*data).wp };
    let mut wme: *mut window_mode_entry = std::ptr::null_mut::<window_mode_entry>();
    wme = unsafe { (*wp).modes.tqh_first };
    if wme.is_null() || (unsafe { (*wme).data }) != modedata {
        return;
    }
    window_buffer_key(
        wme,
        c,
        std::ptr::null_mut::<session>(),
        std::ptr::null_mut::<winlink>(),
        key,
        std::ptr::null_mut::<mouse_event>(),
    );
}
extern "C" fn window_buffer_get_key(
    mut modedata: *mut (),
    mut itemdata: *mut (),
    mut line: u_int,
) -> key_code {
    let mut data: *mut window_buffer_modedata = modedata as *mut window_buffer_modedata;
    let mut item: *mut window_buffer_itemdata = itemdata as *mut window_buffer_itemdata;
    let mut ft: *mut format_tree = std::ptr::null_mut::<format_tree>();
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut expanded: *mut i8 = std::ptr::null_mut::<i8>();
    let mut key: key_code = 0;
    if (unsafe { cmd_find_valid_state(&mut (*data).fs) }) != 0 {
        s = unsafe { (*data).fs.s };
        wl = unsafe { (*data).fs.wl };
        wp = unsafe { (*data).fs.wp };
    }
    pb = unsafe { paste_get_name((*item).name) };
    if pb.is_null() {
        return KEYC_MASK_FLAGS000 as u64;
    }
    ft = unsafe {
        format_create(
            std::ptr::null_mut::<client>(),
            std::ptr::null_mut::<cmdq_item>(), 0, 0,
        )
    };
    (unsafe {
        format_defaults(
            ft,
            std::ptr::null_mut::<client>(),
            std::ptr::null_mut::<session>(),
            std::ptr::null_mut::<winlink>(),
            std::ptr::null_mut::<window_pane>(),
        )
    });
    (unsafe { format_defaults(ft, std::ptr::null_mut::<client>(), s, wl, wp) });
    (unsafe { format_defaults_paste_buffer(ft, pb) });
    (unsafe {
        format_add(
            ft,
            b"line\0" as *const u8 as *const i8,
            b"%u\0" as *const u8 as *const i8,
            line,
        )
    });
    expanded = unsafe { format_expand(ft, (*data).key_format) };
    key = unsafe { key_string_lookup_string(expanded) };
    (unsafe { free(expanded as *mut ()) });
    (unsafe { format_free(ft) });
    return key;
}
extern "C" fn window_buffer_init(
    mut wme: *mut window_mode_entry,
    mut fs: *mut cmd_find_state,
    mut args: *mut args,
) -> *mut screen {
    let mut wp: *mut window_pane = unsafe { (*wme).wp };
    let mut data: *mut window_buffer_modedata = std::ptr::null_mut::<window_buffer_modedata>();
    let mut s: *mut screen = std::ptr::null_mut::<screen>();
    data = (unsafe {
        xcalloc( 1 as size_t,
            ::core::mem::size_of::<window_buffer_modedata>() as u64,
        )
    }) as *mut window_buffer_modedata;
    (unsafe { (*wme).data = data as *mut () });
    (unsafe { (*data).wp = wp });
    (unsafe { cmd_find_copy_state(&mut (*data).fs, fs) });
    if args.is_null() || (unsafe { args_has(args, 'F' as i32 as u_char) }) == 0 {
        (unsafe {
            (*data).format =
                xstrdup(b"#{t/p:buffer_created}: #{buffer_sample}\0" as *const u8 as *const i8)
        });
    } else {
        (unsafe { (*data).format = xstrdup(args_get(args, 'F' as i32 as u_char)) });
    }
    if args.is_null() || (unsafe { args_has(args, 'K' as i32 as u_char) }) == 0 {
        (unsafe {
            (* data) . key_format = xstrdup (b"#{?#{e|<:#{line},10},#{line},#{?#{e|<:#{line},36},M-#{a:#{e|+:97,#{e|-:#{line},10}}},}}\0" as * const u8 as * const i8 ,)
        });
    } else {
        (unsafe { (*data).key_format = xstrdup(args_get(args, 'K' as i32 as u_char)) });
    }
    if args.is_null() || (unsafe { args_count(args) }) == 0 as u32 {
        (unsafe {
            (*data).command = xstrdup(b"paste-buffer -p -b '%%'\0" as *const u8 as *const i8)
        });
    } else {
        (unsafe { (*data).command = xstrdup(args_string(args, 0 as u_int)) });
    }
    (unsafe {
        (*data).data = mode_tree_start(
            wp,
            args,
            Some(
                window_buffer_build
                    as unsafe extern "C" fn(
                        *mut (),
                        *mut mode_tree_sort_criteria,
                        *mut uint64_t,
                        *const i8,
                    ) -> (),
            ),
            Some(
                window_buffer_draw
                    as unsafe extern "C" fn(
                        *mut (),
                        *mut (),
                        *mut screen_write_ctx,
                        u_int,
                        u_int,
                    ) -> (),
            ),
            Some(
                window_buffer_search
                    as unsafe extern "C" fn(*mut (), *mut (), *const i8) -> i32,
            ),
            Some(
                window_buffer_menu
                    as unsafe extern "C" fn(*mut (), *mut client, key_code) -> (),
            ),
            None,
            Some(
                window_buffer_get_key
                    as unsafe extern "C" fn(
                        *mut (),
                        *mut (),
                        u_int,
                    ) -> key_code,
            ),
            data as *mut (),
            window_buffer_menu_items.as_ptr(),
            window_buffer_sort_list.as_mut_ptr(),
            (::core::mem::size_of::<[*const i8; 3]>() as u64)
                .wrapping_div(::core::mem::size_of::<*const i8>() as u64) as u_int,
            &mut s,
        )
    });
    (unsafe { mode_tree_zoom((*data).data, args) });
    (unsafe { mode_tree_build((*data).data) });
    (unsafe { mode_tree_draw((*data).data) });
    return s;
}
extern "C" fn window_buffer_free(mut wme: *mut window_mode_entry) {
    let mut data: *mut window_buffer_modedata =
        (unsafe { (*wme).data }) as *mut window_buffer_modedata;
    let mut i: u_int = 0;
    if data.is_null() {
        return;
    }
    (unsafe { mode_tree_free((*data).data) });
    i = 0 as u_int;
    while i < (unsafe { (*data).item_size }) {
        window_buffer_free_item(unsafe { *((*data).item_list).offset(i as isize) });
        i = i.wrapping_add(1);
    }
    (unsafe { free((*data).item_list as *mut ()) });
    (unsafe { free((*data).format as *mut ()) });
    (unsafe { free((*data).key_format as *mut ()) });
    (unsafe { free((*data).command as *mut ()) });
    (unsafe { free(data as *mut ()) });
}
extern "C" fn window_buffer_resize(mut wme: *mut window_mode_entry, mut sx: u_int, mut sy: u_int) {
    let mut data: *mut window_buffer_modedata =
        (unsafe { (*wme).data }) as *mut window_buffer_modedata;
    (unsafe { mode_tree_resize((*data).data, sx, sy) });
}
extern "C" fn window_buffer_update(mut wme: *mut window_mode_entry) {
    let mut data: *mut window_buffer_modedata =
        (unsafe { (*wme).data }) as *mut window_buffer_modedata;
    (unsafe { mode_tree_build((*data).data) });
    (unsafe { mode_tree_draw((*data).data) });
    (unsafe { (*(*data).wp).flags |= 0x1 as i32 });
}
extern "C" fn window_buffer_do_delete(
    mut modedata: *mut (),
    mut itemdata: *mut (),
    mut _c: *mut client,
    mut _key: key_code,
) {
    let mut data: *mut window_buffer_modedata = modedata as *mut window_buffer_modedata;
    let mut item: *mut window_buffer_itemdata = itemdata as *mut window_buffer_itemdata;
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    if item == (unsafe { mode_tree_get_current((*data).data) }) as *mut window_buffer_itemdata
        && (unsafe { mode_tree_down((*data).data, 0) }) == 0
    {
        (unsafe { mode_tree_up((*data).data, 0) });
    }
    pb = unsafe { paste_get_name((*item).name) };
    if !pb.is_null() {
        (unsafe { paste_free(pb) });
    }
}
extern "C" fn window_buffer_do_paste(
    mut modedata: *mut (),
    mut itemdata: *mut (),
    mut c: *mut client,
    mut _key: key_code,
) {
    let mut data: *mut window_buffer_modedata = modedata as *mut window_buffer_modedata;
    let mut item: *mut window_buffer_itemdata = itemdata as *mut window_buffer_itemdata;
    if !(unsafe { paste_get_name((*item).name) }).is_null() {
        (unsafe {
            mode_tree_run_command(
                c,
                std::ptr::null_mut::<cmd_find_state>(),
                (*data).command,
                (*item).name,
            )
        });
    }
}
extern "C" fn window_buffer_finish_edit(mut ed: *mut window_buffer_editdata) {
    (unsafe { free((*ed).name as *mut ()) });
    (unsafe { free(ed as *mut ()) });
}
extern "C" fn window_buffer_edit_close_cb(
    mut buf: *mut i8,
    mut len: size_t,
    mut arg: *mut (),
) {
    let mut ed: *mut window_buffer_editdata = arg as *mut window_buffer_editdata;
    let mut oldlen: size_t = 0;
    let mut oldbuf: *const i8 = std::ptr::null::<i8>();
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut data: *mut window_buffer_modedata = std::ptr::null_mut::<window_buffer_modedata>();
    let mut wme: *mut window_mode_entry = std::ptr::null_mut::<window_mode_entry>();
    if buf.is_null() || len == 0 as u64 {
        window_buffer_finish_edit(ed);
        return;
    }
    pb = unsafe { paste_get_name((*ed).name) };
    if pb.is_null() || pb != (unsafe { (*ed).pb }) {
        window_buffer_finish_edit(ed);
        return;
    }
    oldbuf = unsafe { paste_buffer_data(pb, &mut oldlen) };
    if oldlen != '\0' as i32 as u64
        && (unsafe { *oldbuf.offset(oldlen.wrapping_sub(1 as i32 as u64) as isize) }) as i32
            != '\n' as i32
        && (unsafe { *buf.offset(len.wrapping_sub(1 as i32 as u64) as isize) }) as i32
            == '\n' as i32
    {
        len = len.wrapping_sub(1);
    }
    if len != 0 as u64 {
        (unsafe { paste_replace(pb, buf, len) });
    }
    wp = unsafe { window_pane_find_by_id((*ed).wp_id) };
    if !wp.is_null() {
        wme = unsafe { (*wp).modes.tqh_first };
        if (unsafe { (*wme).mode }) == (unsafe { &window_buffer_mode }) as *const window_mode {
            data = (unsafe { (*wme).data }) as *mut window_buffer_modedata;
            (unsafe { mode_tree_build((*data).data) });
            (unsafe { mode_tree_draw((*data).data) });
        }
        (unsafe { (*wp).flags |= 0x1 as i32 });
    }
    window_buffer_finish_edit(ed);
}
extern "C" fn window_buffer_start_edit(
    mut data: *mut window_buffer_modedata,
    mut item: *mut window_buffer_itemdata,
    mut c: *mut client,
) {
    let mut pb: *mut paste_buffer = std::ptr::null_mut::<paste_buffer>();
    let mut buf: *const i8 = std::ptr::null::<i8>();
    let mut len: size_t = 0;
    let mut ed: *mut window_buffer_editdata = std::ptr::null_mut::<window_buffer_editdata>();
    pb = unsafe { paste_get_name((*item).name) };
    if pb.is_null() {
        return;
    }
    buf = unsafe { paste_buffer_data(pb, &mut len) };
    ed = (unsafe {
        xcalloc( 1 as size_t,
            ::core::mem::size_of::<window_buffer_editdata>() as u64,
        )
    }) as *mut window_buffer_editdata;
    (unsafe { (*ed).wp_id = (*(*data).wp).id });
    (unsafe { (*ed).name = xstrdup(paste_buffer_name(pb)) });
    (unsafe { (*ed).pb = pb });
    if (unsafe {
        popup_editor(
            c,
            buf,
            len,
            Some(
                window_buffer_edit_close_cb
                    as unsafe extern "C" fn(*mut i8, size_t, *mut ()) -> (),
            ),
            ed as *mut (),
        )
    }) != 0
    {
        window_buffer_finish_edit(ed);
    }
}
extern "C" fn window_buffer_key(
    mut wme: *mut window_mode_entry,
    mut c: *mut client,
    mut _s: *mut session,
    mut _wl: *mut winlink,
    mut key: key_code,
    mut m: *mut mouse_event,
) {
    let mut wp: *mut window_pane = unsafe { (*wme).wp };
    let mut data: *mut window_buffer_modedata =
        (unsafe { (*wme).data }) as *mut window_buffer_modedata;
    let mut mtd: *mut mode_tree_data = unsafe { (*data).data };
    let mut item: *mut window_buffer_itemdata = std::ptr::null_mut::<window_buffer_itemdata>();
    let mut finished: i32 = 0;
    if (unsafe { paste_is_empty() }) != 0 {
        finished = 1;
    } else {
        finished = unsafe {
            mode_tree_key(
                mtd,
                c,
                &mut key,
                m,
                std::ptr::null_mut::<u_int>(),
                std::ptr::null_mut::<u_int>(),
            )
        };
        match key {
            101 => {
                item = (unsafe { mode_tree_get_current(mtd) }) as *mut window_buffer_itemdata;
                window_buffer_start_edit(data, item, c);
            }
            100 => {
                item = (unsafe { mode_tree_get_current(mtd) }) as *mut window_buffer_itemdata;
                window_buffer_do_delete(
                    data as *mut (),
                    item as *mut (),
                    c,
                    key,
                );
                (unsafe { mode_tree_build(mtd) });
            }
            68 => {
                (unsafe {
                    mode_tree_each_tagged(
                        mtd,
                        Some(
                            window_buffer_do_delete
                                as unsafe extern "C" fn(
                                    *mut (),
                                    *mut (),
                                    *mut client,
                                    key_code,
                                ) -> (),
                        ),
                        c,
                        key, 0,
                    )
                });
                (unsafe { mode_tree_build(mtd) });
            }
            80 => {
                (unsafe {
                    mode_tree_each_tagged(
                        mtd,
                        Some(
                            window_buffer_do_paste
                                as unsafe extern "C" fn(
                                    *mut (),
                                    *mut (),
                                    *mut client,
                                    key_code,
                                ) -> (),
                        ),
                        c,
                        key, 0,
                    )
                });
                finished = 1;
            }
            112 | 13 => {
                item = (unsafe { mode_tree_get_current(mtd) }) as *mut window_buffer_itemdata;
                window_buffer_do_paste(
                    data as *mut (),
                    item as *mut (),
                    c,
                    key,
                );
                finished = 1;
            }
            _ => {}
        }
    }
    if finished != 0 || (unsafe { paste_is_empty() }) != 0 {
        (unsafe { window_pane_reset_mode(wp) });
    } else {
        (unsafe { mode_tree_draw(mtd) });
        (unsafe { (*wp).flags |= 0x1 as i32 });
    };
}
